home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / swingall.jar / javax / swing / tree / FixedHeightLayoutCache.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-07-15  |  10.0 KB  |  477 lines
  1. package javax.swing.tree;
  2.  
  3. import java.awt.Rectangle;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.Stack;
  7. import java.util.Vector;
  8. import javax.swing.event.TreeModelEvent;
  9.  
  10. public class FixedHeightLayoutCache extends AbstractLayoutCache {
  11.    private FHTreeStateNode root;
  12.    private int rowCount;
  13.    private Rectangle boundsBuffer = new Rectangle();
  14.    private Hashtable treePathMapping = new Hashtable();
  15.    private SearchInfo info = new SearchInfo(this);
  16.    private Stack tempStacks = new Stack();
  17.  
  18.    // $FF: synthetic method
  19.    static void access$0(FixedHeightLayoutCache var0, FHTreeStateNode var1) {
  20.       var0.addMapping(var1);
  21.    }
  22.  
  23.    // $FF: synthetic method
  24.    static void access$1(FixedHeightLayoutCache var0, FHTreeStateNode var1) {
  25.       var0.removeMapping(var1);
  26.    }
  27.  
  28.    // $FF: synthetic method
  29.    static FHTreeStateNode access$2(FixedHeightLayoutCache var0, Object var1, int var2) {
  30.       return var0.createNodeForValue(var1, var2);
  31.    }
  32.  
  33.    // $FF: synthetic method
  34.    static void access$3(FixedHeightLayoutCache var0, int var1) {
  35.       var0.adjustRowCountBy(var1);
  36.    }
  37.  
  38.    // $FF: synthetic method
  39.    static int access$4(FixedHeightLayoutCache var0) {
  40.       return var0.rowCount;
  41.    }
  42.  
  43.    // $FF: synthetic method
  44.    static void access$5(FixedHeightLayoutCache var0, int var1) {
  45.       var0.rowCount = var1;
  46.    }
  47.  
  48.    // $FF: synthetic method
  49.    static FHTreeStateNode access$6(FixedHeightLayoutCache var0) {
  50.       return var0.root;
  51.    }
  52.  
  53.    private void addMapping(FHTreeStateNode var1) {
  54.       this.treePathMapping.put(var1.getTreePath(), var1);
  55.    }
  56.  
  57.    private void adjustRowCountBy(int var1) {
  58.       this.rowCount += var1;
  59.    }
  60.  
  61.    private FHTreeStateNode createNodeForValue(Object var1, int var2) {
  62.       return new FHTreeStateNode(this, var1, var2, -1);
  63.    }
  64.  
  65.    private boolean ensurePathIsExpanded(TreePath var1, boolean var2) {
  66.       if (var1 != null) {
  67.          if (super.treeModel.isLeaf(var1.getLastPathComponent())) {
  68.             var1 = var1.getParentPath();
  69.             var2 = true;
  70.          }
  71.  
  72.          if (var1 != null) {
  73.             FHTreeStateNode var3 = this.getNodeForPath(var1, false, true);
  74.             if (var3 != null) {
  75.                var3.makeVisible();
  76.                if (var2) {
  77.                   var3.expand();
  78.                }
  79.  
  80.                return true;
  81.             }
  82.          }
  83.       }
  84.  
  85.       return false;
  86.    }
  87.  
  88.    private Rectangle getBounds(FHTreeStateNode var1, int var2, Rectangle var3) {
  89.       boolean var4;
  90.       int var5;
  91.       int var6;
  92.       Object var7;
  93.       if (var2 == -1) {
  94.          var6 = var1.getRow();
  95.          var7 = ((DefaultMutableTreeNode)var1).getUserObject();
  96.          var4 = var1.isExpanded();
  97.          var5 = ((DefaultMutableTreeNode)var1).getLevel();
  98.       } else {
  99.          var6 = var1.getRowToModelIndex(var2);
  100.          var7 = super.treeModel.getChild(((DefaultMutableTreeNode)var1).getUserObject(), var2);
  101.          var4 = false;
  102.          var5 = ((DefaultMutableTreeNode)var1).getLevel() + 1;
  103.       }
  104.  
  105.       Rectangle var8 = ((AbstractLayoutCache)this).getNodeDimensions(var7, var6, var5, var4, this.boundsBuffer);
  106.       if (var8 == null) {
  107.          return null;
  108.       } else {
  109.          if (var3 == null) {
  110.             var3 = new Rectangle();
  111.          }
  112.  
  113.          var3.x = var8.x;
  114.          var3.height = ((AbstractLayoutCache)this).getRowHeight();
  115.          var3.y = var6 * var3.height;
  116.          var3.width = this.boundsBuffer.width;
  117.          return var3;
  118.       }
  119.    }
  120.  
  121.    public Rectangle getBounds(TreePath var1, Rectangle var2) {
  122.       if (var1 == null) {
  123.          return null;
  124.       } else {
  125.          FHTreeStateNode var3 = this.getNodeForPath(var1, true, false);
  126.          if (var3 != null) {
  127.             return this.getBounds(var3, -1, var2);
  128.          } else {
  129.             TreePath var4 = var1.getParentPath();
  130.             var3 = this.getNodeForPath(var4, true, false);
  131.             if (var3 != null) {
  132.                int var5 = super.treeModel.getIndexOfChild(var4.getLastPathComponent(), var1.getLastPathComponent());
  133.                if (var5 != -1) {
  134.                   return this.getBounds(var3, var5, var2);
  135.                }
  136.             }
  137.  
  138.             return null;
  139.          }
  140.       }
  141.    }
  142.  
  143.    public boolean getExpandedState(TreePath var1) {
  144.       FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  145.       return var2 != null ? var2.isVisible() && var2.isExpanded() : false;
  146.    }
  147.  
  148.    private FHTreeStateNode getMapping(TreePath var1) {
  149.       return (FHTreeStateNode)this.treePathMapping.get(var1);
  150.    }
  151.  
  152.    private FHTreeStateNode getNodeForPath(TreePath var1, boolean var2, boolean var3) {
  153.       if (var1 != null) {
  154.          FHTreeStateNode var4 = this.getMapping(var1);
  155.          if (var4 != null) {
  156.             return var2 && !var4.isVisible() ? null : var4;
  157.          } else if (var2) {
  158.             return null;
  159.          } else {
  160.             Stack var5;
  161.             if (this.tempStacks.size() == 0) {
  162.                var5 = new Stack();
  163.             } else {
  164.                var5 = (Stack)this.tempStacks.pop();
  165.             }
  166.  
  167.             try {
  168.                var5.push(var1);
  169.                var1 = var1.getParentPath();
  170.  
  171.                for(Object var13 = null; var1 != null; var1 = var1.getParentPath()) {
  172.                   var4 = this.getMapping(var1);
  173.                   if (var4 != null) {
  174.                      while(var4 != null && ((Vector)var5).size() > 0) {
  175.                         var1 = (TreePath)var5.pop();
  176.                         var4 = var4.createChildFor(var1.getLastPathComponent());
  177.                      }
  178.  
  179.                      FHTreeStateNode var6 = var4;
  180.                      return var6;
  181.                   }
  182.  
  183.                   var5.push(var1);
  184.                }
  185.  
  186.                return null;
  187.             } finally {
  188.                ((Vector)var5).removeAllElements();
  189.                this.tempStacks.push(var5);
  190.             }
  191.          }
  192.       } else {
  193.          return null;
  194.       }
  195.    }
  196.  
  197.    public TreePath getPathClosestTo(int var1, int var2) {
  198.       if (this.getRowCount() == 0) {
  199.          return null;
  200.       } else {
  201.          int var3 = this.getRowContainingYLocation(var2);
  202.          return this.getPathForRow(var3);
  203.       }
  204.    }
  205.  
  206.    public TreePath getPathForRow(int var1) {
  207.       return var1 >= 0 && var1 < this.getRowCount() && this.root.getPathForRow(var1, this.getRowCount(), this.info) ? this.info.getPath() : null;
  208.    }
  209.  
  210.    private int getRowContainingYLocation(int var1) {
  211.       return this.getRowCount() == 0 ? -1 : Math.max(0, Math.min(this.getRowCount() - 1, var1 / ((AbstractLayoutCache)this).getRowHeight()));
  212.    }
  213.  
  214.    public int getRowCount() {
  215.       return this.rowCount;
  216.    }
  217.  
  218.    public int getRowForPath(TreePath var1) {
  219.       if (var1 != null && this.root != null) {
  220.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  221.          if (var2 != null) {
  222.             return var2.getRow();
  223.          } else {
  224.             TreePath var3 = var1.getParentPath();
  225.             var2 = this.getNodeForPath(var3, true, false);
  226.             return var2 != null ? var2.getRowToModelIndex(super.treeModel.getIndexOfChild(var3.getLastPathComponent(), var1.getLastPathComponent())) : -1;
  227.          }
  228.       } else {
  229.          return -1;
  230.       }
  231.    }
  232.  
  233.    public int getVisibleChildCount(TreePath var1) {
  234.       FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  235.       return var2 == null ? 0 : var2.getTotalChildCount();
  236.    }
  237.  
  238.    public Enumeration getVisiblePathsFrom(TreePath var1) {
  239.       if (var1 == null) {
  240.          return null;
  241.       } else {
  242.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  243.          if (var2 != null) {
  244.             return new VisibleFHTreeStateNodeEnumeration(this, var2);
  245.          } else {
  246.             TreePath var3 = var1.getParentPath();
  247.             var2 = this.getNodeForPath(var3, true, false);
  248.             return var2 != null && var2.isExpanded() ? new VisibleFHTreeStateNodeEnumeration(this, var2, super.treeModel.getIndexOfChild(var3.getLastPathComponent(), var1.getLastPathComponent())) : null;
  249.          }
  250.       }
  251.    }
  252.  
  253.    public void invalidatePathBounds(TreePath var1) {
  254.    }
  255.  
  256.    public void invalidateSizes() {
  257.       this.visibleNodesChanged();
  258.    }
  259.  
  260.    public boolean isExpanded(TreePath var1) {
  261.       if (var1 == null) {
  262.          return false;
  263.       } else {
  264.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  265.          return var2 != null && var2.isExpanded();
  266.       }
  267.    }
  268.  
  269.    private void rebuild() {
  270.       this.treePathMapping.clear();
  271.       if (super.treeModel != null) {
  272.          Object var1 = super.treeModel.getRoot();
  273.          this.root = this.createNodeForValue(var1, 0);
  274.          this.root.path = new TreePath(var1);
  275.          this.addMapping(this.root);
  276.          if (((AbstractLayoutCache)this).isRootVisible()) {
  277.             this.rowCount = 1;
  278.             this.root.row = 0;
  279.          } else {
  280.             this.rowCount = 0;
  281.             this.root.row = -1;
  282.          }
  283.  
  284.          this.root.expand();
  285.       } else {
  286.          this.root = null;
  287.          this.rowCount = 0;
  288.       }
  289.  
  290.       if (super.treeSelectionModel != null) {
  291.          super.treeSelectionModel.clearSelection();
  292.       }
  293.  
  294.       this.visibleNodesChanged();
  295.    }
  296.  
  297.    private void removeMapping(FHTreeStateNode var1) {
  298.       this.treePathMapping.remove(var1.getTreePath());
  299.    }
  300.  
  301.    public void setExpandedState(TreePath var1, boolean var2) {
  302.       if (var2) {
  303.          this.ensurePathIsExpanded(var1, true);
  304.       } else if (var1 != null) {
  305.          TreePath var3 = var1.getParentPath();
  306.          if (var3 != null) {
  307.             FHTreeStateNode var4 = this.getNodeForPath(var3, false, true);
  308.             if (var4 != null) {
  309.                var4.makeVisible();
  310.             }
  311.          }
  312.  
  313.          FHTreeStateNode var5 = this.getNodeForPath(var1, true, false);
  314.          if (var5 != null) {
  315.             var5.collapse(true);
  316.          }
  317.       }
  318.  
  319.    }
  320.  
  321.    public void setModel(TreeModel var1) {
  322.       super.setModel(var1);
  323.       this.rebuild();
  324.    }
  325.  
  326.    public void setRootVisible(boolean var1) {
  327.       if (((AbstractLayoutCache)this).isRootVisible() != var1) {
  328.          super.setRootVisible(var1);
  329.          if (this.root != null) {
  330.             if (var1) {
  331.                ++this.rowCount;
  332.                this.root.adjustRowBy(1);
  333.             } else {
  334.                --this.rowCount;
  335.                this.root.adjustRowBy(-1);
  336.             }
  337.  
  338.             this.visibleNodesChanged();
  339.          }
  340.       }
  341.  
  342.    }
  343.  
  344.    public void setRowHeight(int var1) {
  345.       if (var1 <= 0) {
  346.          throw new IllegalArgumentException("FixedHeightLayoutCache only supports row heights greater than 0");
  347.       } else {
  348.          if (((AbstractLayoutCache)this).getRowHeight() != var1) {
  349.             super.setRowHeight(var1);
  350.             this.visibleNodesChanged();
  351.          }
  352.  
  353.       }
  354.    }
  355.  
  356.    public void treeNodesChanged(TreeModelEvent var1) {
  357.       if (var1 != null) {
  358.          FHTreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  359.          int[] var2 = var1.getChildIndices();
  360.          if (var3 != null) {
  361.             int var4;
  362.             if (var2 != null && (var4 = var2.length) > 0) {
  363.                Object var5 = ((DefaultMutableTreeNode)var3).getUserObject();
  364.  
  365.                for(int var6 = 0; var6 < var4; ++var6) {
  366.                   FHTreeStateNode var7 = var3.getChildAtModelIndex(var2[var6]);
  367.                   if (var7 != null) {
  368.                      var7.setUserObject(super.treeModel.getChild(var5, var2[var6]));
  369.                   }
  370.                }
  371.  
  372.                if (var3.isVisible() && var3.isExpanded()) {
  373.                   this.visibleNodesChanged();
  374.                }
  375.             } else if (var3 == this.root && var3.isVisible() && var3.isExpanded()) {
  376.                this.visibleNodesChanged();
  377.             }
  378.          }
  379.       }
  380.  
  381.    }
  382.  
  383.    public void treeNodesInserted(TreeModelEvent var1) {
  384.       if (var1 != null) {
  385.          FHTreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  386.          int[] var2 = var1.getChildIndices();
  387.          int var4;
  388.          if (var3 != null && var2 != null && (var4 = var2.length) > 0) {
  389.             boolean var5 = var3.isVisible() && var3.isExpanded();
  390.  
  391.             for(int var6 = 0; var6 < var4; ++var6) {
  392.                var3.childInsertedAtModelIndex(var2[var6], var5);
  393.             }
  394.  
  395.             if (var5 && super.treeSelectionModel != null) {
  396.                super.treeSelectionModel.resetRowSelection();
  397.             }
  398.  
  399.             if (var3.isVisible()) {
  400.                this.visibleNodesChanged();
  401.             }
  402.          }
  403.       }
  404.  
  405.    }
  406.  
  407.    public void treeNodesRemoved(TreeModelEvent var1) {
  408.       if (var1 != null) {
  409.          TreePath var4 = var1.getTreePath();
  410.          FHTreeStateNode var5 = this.getNodeForPath(var4, false, false);
  411.          int[] var2 = var1.getChildIndices();
  412.          int var3;
  413.          if (var5 != null && var2 != null && (var3 = var2.length) > 0) {
  414.             Object[] var6 = var1.getChildren();
  415.             boolean var7 = var5.isVisible() && var5.isExpanded();
  416.  
  417.             for(int var8 = var3 - 1; var8 >= 0; --var8) {
  418.                var5.removeChildAtModelIndex(var2[var8], var7);
  419.                if (super.treeSelectionModel != null && var6 != null && var6[var8] != null) {
  420.                   super.treeSelectionModel.removeSelectionPath(var4.pathByAddingChild(var6[var8]));
  421.                }
  422.             }
  423.  
  424.             if (var7) {
  425.                if (super.treeSelectionModel != null) {
  426.                   super.treeSelectionModel.resetRowSelection();
  427.                }
  428.  
  429.                this.visibleNodesChanged();
  430.             } else if (var5.isVisible()) {
  431.                this.visibleNodesChanged();
  432.             }
  433.          }
  434.       }
  435.  
  436.    }
  437.  
  438.    public void treeStructureChanged(TreeModelEvent var1) {
  439.       if (var1 != null) {
  440.          TreePath var2 = var1.getTreePath();
  441.          if (var2 != null && var2.getPathCount() > 0) {
  442.             if (var2.getPathCount() == 1) {
  443.                this.rebuild();
  444.             } else {
  445.                FHTreeStateNode var3 = this.getNodeForPath(var2, false, false);
  446.                if (var3 != null) {
  447.                   FHTreeStateNode var7 = (FHTreeStateNode)((DefaultMutableTreeNode)var3).getParent();
  448.                   int var8 = var3.getRow();
  449.                   boolean var4 = var3.isExpanded();
  450.                   boolean var5 = var3.isVisible();
  451.                   if (var5 && var4) {
  452.                      var3.collapse(true);
  453.                      ((DefaultMutableTreeNode)var3).removeFromParent();
  454.                      var3 = this.getNodeForPath(var2, false, true);
  455.                      var3.expand();
  456.                   } else {
  457.                      ((DefaultMutableTreeNode)var3).removeFromParent();
  458.                   }
  459.  
  460.                   if (super.treeSelectionModel != null && var5 && var4) {
  461.                      super.treeSelectionModel.resetRowSelection();
  462.                   }
  463.  
  464.                   if (var5) {
  465.                      this.visibleNodesChanged();
  466.                   }
  467.                }
  468.             }
  469.          }
  470.       }
  471.  
  472.    }
  473.  
  474.    private void visibleNodesChanged() {
  475.    }
  476. }
  477.